home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / EvalC3.mi < prev    next >
Text File  |  1992-11-24  |  32KB  |  1,036 lines
  1. IMPLEMENTATION MODULE EvalC3;
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. IMPORT SYSTEM, System, IO, Tree;
  16. (* line 7 "" *)
  17.  
  18.  
  19. FROM SYSTEM    IMPORT ADR, TSIZE;
  20. FROM General    IMPORT Max;
  21. FROM DynArray    IMPORT MakeArray;
  22. FROM IO        IMPORT WriteS, WriteNl, WriteI, WriteB, StdOutput;
  23. FROM Texts    IMPORT WriteText;
  24. FROM Sets    IMPORT tSet, MakeSet, ReleaseSet, Include, Exclude, Minimum,
  25.             Maximum, IsElement, WriteSet, IsEmpty, Extract;
  26. FROM Relations    IMPORT IsRelated;
  27. FROM TreeC1    IMPORT BSS;
  28. FROM TreeC2    IMPORT GetIterator, Iterator, WriteLine;
  29. FROM EvalC    IMPORT Class;
  30. FROM Errors    IMPORT Error, Short, MessageI;
  31. FROM Positions    IMPORT NoPosition;
  32. IMPORT EvalC;
  33.  
  34. FROM Tree    IMPORT
  35.    NoTree    , tTree        , Referenced    , NoCodeClass    ,
  36.    Computed    , Reverse    , Write        , Read        ,
  37.    Inherited    , Synthesized    , Input        , Output    ,
  38.    Virtual    , Test        , Left        , Right        ,
  39.    HasOutput    , NonBaseComp    , Dummy        , Trace        ,
  40.    Demand    , Funct        , NoClass    , Options    ,
  41.    TreeRoot    , iModule    , iMain        , itTree    ,
  42.    ForallClasses, ForallAttributes, f        , WI    , WN    ,
  43.    ClassCount    , IdentifyClass    , IdentifyAttribute, 
  44.    tBitIndex    , tBitInfo    , iNoTree    , QueryTree    ;
  45.  
  46. VAR
  47.    i, i2, j, k, n, MaxBit, MaxInstCount, Check: SHORTCARD;
  48.    Node, Attr, ChildsClass    : tTree;
  49.    Success, IsStable        : BOOLEAN;
  50.    BitIndexSize            : LONGINT;
  51.    gBitIndex            : tBitIndex;
  52.    InhIndices            : tSet;
  53.    InhIndexSize            : LONGINT;
  54.    InhIndexCount        : POINTER TO ARRAY [1..1000000] OF SHORTCARD;
  55.  
  56. PROCEDURE GenCall (t: tTree; j: SHORTCARD);
  57.    BEGIN
  58.       WITH t^.Class.Instance^ [j] DO
  59.      IF ({Synthesized, Left} <= Properties) THEN
  60.         k := ToBit0 (t, j);
  61.         WriteS (f, "IFNOTIN ("); WN (k MOD BSS); WriteS (f, ", yyt->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ") "); 
  62.         WriteS (f, "yyS"); WN (k); WriteS (f, " (yyt); /* "); WI (Attribute^.Child.Name); WriteS (f, " */ }"); WriteNl (f);
  63.      ELSIF ({Inherited, Left} <= Properties) THEN
  64.         k := ToBit0 (t, j);
  65.         WriteS (f, "IFNOTIN ("); WN (k MOD BSS); WriteS (f, ", yyt->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ") "); 
  66.    IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  67.         WriteS (f, "yyVisitParent (yyt); "); 
  68.         WriteS (f, "yyI [yyt->yyHead.yyOffset + "); WN (k); WriteS (f, "](yyt->yyHead.yyParent); /* "); 
  69.         WI (Attribute^.Child.Name); WriteS (f, " */ "); 
  70.         WriteS (f, 'yyWriteVisit (yyt->yyHead.yyParent, "?"); }'); WriteNl (f);
  71.    ELSE
  72.         WriteS (f, "yyI [yyt->yyHead.yyOffset + "); WN (k); WriteS (f, "](yyt->yyHead.yyParent); /* "); 
  73.         WI (Attribute^.Child.Name); WriteS (f, " */ }"); WriteNl (f);
  74.    END;
  75.      ELSIF ({Inherited, Right} <= Properties) THEN
  76.         k := ToBit1 (Selector, j - t^.Class.AttrCount - Selector^.Child.InstOffset);
  77.         WriteS (f, "IFNOTIN ("); WN (k MOD BSS); WriteS (f, ", yyt->"); WI (Class^.Class.Name);
  78.         WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, "->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ") "); 
  79.         k := ToBit2 (t, Selector, j);
  80.         WriteS (f, "yyI"); WN (k); WriteS (f, " (yyt); /* "); WI (Selector^.Child.Name);
  81.         WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, " */ }"); WriteNl (f);
  82.      ELSIF ({Synthesized, Right} <= Properties) THEN
  83.         k := ToBit1 (Selector, j - t^.Class.AttrCount - Selector^.Child.InstOffset);
  84.         WriteS (f, "IFNOTIN ("); WN (k MOD BSS); WriteS (f, ", yyt->"); WI (Class^.Class.Name);
  85.         WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, "->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ") "); 
  86.    IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  87.         WriteS (f, 'yyWriteVisit (yyt, "'); WI (Selector^.Child.Name); WriteS (f, '"); '); 
  88.         WriteS (f, "yyS"); WN (k);
  89.         WriteS (f, " (yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name);
  90.         WriteS (f, "); /* "); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, " */ "); 
  91.         WriteS (f, "yyVisitParent (yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, "); }"); WriteNl (f);
  92.    ELSE
  93.         WriteS (f, "yyS"); WN (k);
  94.         WriteS (f, " (yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name);
  95.         WriteS (f, "); /* "); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, " */ }"); WriteNl (f);
  96.    END;
  97.      END;
  98.       END;
  99.    END GenCall;
  100.  
  101. PROCEDURE GenEvalAttr (t: tTree; i: INTEGER);
  102.    BEGIN
  103.       Class := t;
  104.       WITH t^.Class.Instance^ [i] DO
  105.    IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  106.      WriteS (f, 'yyWriteEval (yyt, "'); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  107.      IF (Action # ADR (Action)) AND NOT (Virtual IN Properties) THEN
  108.         EvalC.GenEvaluator (Action); WriteNl (f);
  109.         IF Test IN Properties THEN
  110.            WriteS (f, "writebool (yyb) yyWriteNl ();"); WriteNl (f);
  111.         ELSIF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  112.            WriteS (f, "write"); WI (itTree);
  113.            WriteS (f, " (yyt->"); WI (t^.Class.Name); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ")"); WriteNl (f);
  114.         ELSE
  115.            WriteS (f, "write"); WI (Attribute^.Child.Type);
  116.            WriteS (f, " (yyt->"); WI (t^.Class.Name); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ") yyWriteNl ();"); WriteNl (f);
  117.         END;
  118.      ELSE
  119.         WriteS (f, "yyWriteNl ();"); WriteNl (f);
  120.      END;
  121.    ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  122.      WriteS (f, 'yyWriteEval (yyt, "'); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  123.      IF (Action # ADR (Action)) AND NOT (Virtual IN Properties) THEN
  124.         EvalC.GenEvaluator (Action);
  125.      END;
  126.    ELSE
  127.      IF (Action # ADR (Action)) AND NOT (Virtual IN Properties) THEN
  128.         EvalC.GenEvaluator (Action);
  129.      END;
  130.    END;
  131.       END;
  132.    END GenEvalAttr;
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139.  
  140.  
  141.  
  142.  
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.  
  155.  
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180.  
  181.  
  182.  
  183.  
  184.  
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239. PROCEDURE yyAbort (yyFunction: ARRAY OF CHAR);
  240.  BEGIN
  241.   IO.WriteS (IO.StdError, 'Error: module EvalC3, routine ');
  242.   IO.WriteS (IO.StdError, yyFunction);
  243.   IO.WriteS (IO.StdError, ' failed');
  244.   IO.WriteNl (IO.StdError);
  245.   Exit;
  246.  END yyAbort;
  247.  
  248. PROCEDURE yyIsEqual (yya, yyb: ARRAY OF SYSTEM.BYTE): BOOLEAN;
  249.  VAR yyi    : INTEGER;
  250.  BEGIN
  251.   FOR yyi := 0 TO INTEGER (HIGH (yya)) DO
  252.    IF yya [yyi] # yyb [yyi] THEN RETURN FALSE; END;
  253.   END;
  254.   RETURN TRUE;
  255.  END yyIsEqual;
  256.  
  257. PROCEDURE EvalImplC (t: Tree.tTree);
  258.  VAR yyTempo: RECORD CASE : INTEGER OF
  259.  | 2: yyR2: RECORD
  260.   a: SHORTCARD;
  261.   END;
  262.  END; END;
  263.  BEGIN
  264.   IF t = Tree.NoTree THEN RETURN; END;
  265.   IF (t^.Kind = Tree.Ag) THEN
  266. (* line 127 "" *)
  267.      WITH t^.Ag DO
  268. (* line 127 "" *)
  269.       
  270.     MaxBit := 0;
  271.     MaxInstCount := 0;
  272.     ForallClasses (Classes, CompBitInfo);
  273.     MakeSet (InhIndices, MaxInstCount);
  274.     InhIndexSize := MaxInstCount;
  275.     MakeArray (InhIndexCount, InhIndexSize, TSIZE (SHORTCARD));
  276.     FOR i := 1 TO MaxInstCount DO InhIndexCount^ [i] := 0; END;
  277.     ForallClasses (Classes, CompInhIndices);
  278.     WriteS (f, '# define IFNOTIN(b, s) if (! (s & 1 << b)) {'); WriteNl (f);
  279.     WriteS (f, "# define INCL(s, b) s |= 1 << b"); WriteNl (f);
  280.     WriteS (f, "# define REMOTE_SYN(i, b, c, n, t, a) (n->yyHead.i & 1 << b ? (void) 0 : c (n), n->t.a)"); WriteNl (f);
  281.     WriteS (f, "# define REMOTE_INH(i, b, k, n, t, a) (n->yyHead.i & 1 << b ? (void) 0 : yyI [n->yyHead.yyOffset + k](n->yyHead.yyParent), n->t.a)"); WriteNl (f);
  282.     EvalC.EvalImplHead (t);
  283.     WriteNl (f);
  284.     WriteS (f, "static void yyE ARGS((register "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  285.     FOR i := 1 TO MaxBit - 1 DO
  286.        WriteS (f, "static void yyS"); WN (i); WriteS (f, " ARGS((register "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  287.     END;
  288.     FOR i := Minimum (InhIndices) TO Maximum (InhIndices) DO
  289.        IF IsElement (i, InhIndices) THEN
  290.           WriteS (f, "static void yyI"); WN (i); WriteS (f, " ARGS((register "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  291.        END;
  292.     END;
  293.     WriteNl (f);
  294.     WriteS (f, "static "); WI (iMain); WriteS (f, "_tProcTree yyI ["); WN (Maximum (InhIndices) + 1); WriteS (f, "] = { 0,"); WriteNl (f);
  295.     FOR i := 1 TO Maximum (InhIndices) DO
  296.        IF IsElement (i, InhIndices) THEN
  297.           WriteS (f, " yyI"); WN (i); WriteS (f, ","); WriteNl (f);
  298.        ELSE
  299.           WriteS (f, " 0,"); WriteNl (f);
  300.        END;
  301.     END;
  302.     WriteS (f, "};"); WriteNl (f);
  303.     WriteNl (f);
  304.     WriteS (f, "static void yyAbort"); WriteNl (f);
  305.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  306.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  307.     WriteS (f, "# else"); WriteNl (f);
  308.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  309.     WriteS (f, "# endif"); WriteNl (f);
  310.     WriteS (f, "{"); WriteNl (f);
  311.     WriteS (f, ' (void) fprintf (stderr, "Error: module '); WI (EvalName); WriteS (f, ', cyclic dependencies\n");'); WriteNl (f);
  312.     WriteS (f, " "); WI (iMain); WriteS (f, "_Exit ();"); WriteNl (f);
  313.     WriteS (f, "}"); WriteNl (f);
  314.     WriteNl (f);
  315.     WriteS (f, "void "); WI (EvalName); WriteNl (f);
  316.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  317.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  318.     WriteS (f, "# else"); WriteNl (f);
  319.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  320.     WriteS (f, "# endif"); WriteNl (f);
  321.       IF NOT IsElement (ORD ('9'), Options) THEN
  322.     WriteS (f, "{ Init"); WI (iModule); WriteS (f, " (yyt); yyE (yyt); }"); WriteNl (f);
  323.       ELSE
  324.     WriteS (f, "{"); WriteNl (f);
  325.     WriteS (f, " char xxHigh;"); WriteNl (f);
  326.     WriteS (f, " xxStack = 1000000000;"); WriteNl (f);
  327.     WriteS (f, " Init"); WI (iModule); WriteS (f, " (yyt); yyE (yyt);"); WriteNl (f);
  328.     WriteS (f, ' (void) printf ("Stacksize %d\n", (int) & xxHigh - xxStack);'); WriteNl (f);
  329.     WriteS (f, "}"); WriteNl (f);
  330.       END;
  331.     WriteNl (f);
  332.     REPEAT IsStable := TRUE; ForallClasses (Classes, CompOutput); UNTIL IsStable;
  333.     WriteS (f, "static void yyE"); WriteNl (f);
  334.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  335.     WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  336.     WriteS (f, "# else"); WriteNl (f);
  337.     WriteS (f, " (yyt) register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  338.     WriteS (f, "# endif"); WriteNl (f);
  339.     WriteS (f, "{"); WriteNl (f);
  340.     WriteLine (TreeRoot^.Ag.EvalCodes^.Codes.LocalLine);
  341.     WriteText (f, TreeRoot^.Ag.EvalCodes^.Codes.Local);
  342.     Node := TreeRoot^.Ag.Modules;
  343.     WHILE Node^.Kind = Tree.Module DO
  344.        WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  345.        WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  346.        Node := Node^.Module.Next;
  347.     END;
  348.       IF IsElement (ORD ('9'), Options) THEN
  349.     WriteS (f, " char xxLow;"); WriteNl (f);
  350.     WriteS (f, " xxStack = Min (xxStack, (int) & xxLow);"); WriteNl (f);
  351.       END;
  352.     WriteS (f, " for (;;) {"); WriteNl (f);
  353.     WriteS (f, "  if (yyt == "); WI (iNoTree); WriteS (f, " || yyt->yyHead.yyIsComp0 & 1) return;"); WriteNl (f);
  354.     WriteS (f, "  yyt->yyHead.yyIsComp0 |= 1;"); WriteNl (f);
  355.     WriteS (f, "  switch (yyt->Kind) {"); WriteNl (f);
  356.     ForallClasses (Classes, GenE);
  357.     WriteS (f, "  default: return;"); WriteNl (f);
  358.     WriteS (f, "  }"); WriteNl (f);
  359.     WriteS (f, " }"); WriteNl (f);
  360.     WriteS (f, "}"); WriteNl (f);
  361.     WriteNl (f);
  362.     FOR i := 2 TO MaxBit DO
  363.        n := 0;            (* are there any SYN attributes ? *)
  364.        ForallClasses (Classes, CountSynAttr);
  365.        IF n > 0 THEN
  366.           WriteS (f, "static void yyS"); WN (i - 1); WriteNl (f);
  367.           WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  368.           WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  369.           WriteS (f, "# else"); WriteNl (f);
  370.           WriteS (f, " (yyt) register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  371.           WriteS (f, "# endif"); WriteNl (f);
  372.           WriteS (f, "{"); WriteNl (f);
  373.           WriteLine (TreeRoot^.Ag.EvalCodes^.Codes.LocalLine);
  374.           WriteText (f, TreeRoot^.Ag.EvalCodes^.Codes.Local);
  375.           Node := TreeRoot^.Ag.Modules;
  376.           WHILE Node^.Kind = Tree.Module DO
  377.          WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  378.          WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  379.          Node := Node^.Module.Next;
  380.           END;
  381.       IF IsElement (ORD ('9'), Options) THEN
  382.           WriteS (f, " char xxLow;"); WriteNl (f);
  383.           WriteS (f, " xxStack = Min (xxStack, (int) & xxLow);"); WriteNl (f);
  384.       END;
  385.       IF IsElement (ORD ('5'), Options) THEN
  386.           WriteS (f, " IFNOTIN ("); WN ((i - 1) MOD BSS); WriteS (f, ", yyt->yyHead.yyIsDone"); WN ((i - 1) DIV BSS);
  387.           WriteS (f, ") INCL (yyt->yyHead.yyIsDone"); WN ((i - 1) DIV BSS); WriteS (f, ", "); WN ((i - 1) MOD BSS); WriteS (f, "); } else yyAbort (yyt);"); WriteNl (f);
  388.       END;
  389.           IF n > 1 THEN
  390.          WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  391.          ForallClasses (Classes, GenS);
  392.          WriteS (f, " }"); WriteNl (f);
  393.           ELSE
  394.          ForallClasses (Classes, GenS);
  395.           END;
  396.           WriteS (f, " INCL (yyt->yyHead.yyIsComp"); WN ((i - 1) DIV BSS); WriteS (f, ", "); WN ((i - 1) MOD BSS); WriteS (f, ");"); WriteNl (f);
  397.           WriteS (f, "}"); WriteNl (f);
  398.           WriteNl (f);
  399.        END;
  400.     END;
  401.     FOR i := Minimum (InhIndices) TO Maximum (InhIndices) DO
  402.        IF IsElement (i, InhIndices) THEN
  403.           WriteS (f, "static void yyI"); WN (i); WriteNl (f);
  404.           WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  405.           WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  406.           WriteS (f, "# else"); WriteNl (f);
  407.           WriteS (f, " (yyt) register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  408.           WriteS (f, "# endif"); WriteNl (f);
  409.           WriteS (f, "{"); WriteNl (f);
  410.           WriteLine (TreeRoot^.Ag.EvalCodes^.Codes.LocalLine);
  411.           WriteText (f, TreeRoot^.Ag.EvalCodes^.Codes.Local);
  412.           Node := TreeRoot^.Ag.Modules;
  413.           WHILE Node^.Kind = Tree.Module DO
  414.          WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  415.          WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  416.          Node := Node^.Module.Next;
  417.           END;
  418.       IF IsElement (ORD ('9'), Options) THEN
  419.           WriteS (f, " char xxLow;"); WriteNl (f);
  420.           WriteS (f, " xxStack = Min (xxStack, (int) & xxLow);"); WriteNl (f);
  421.       END;
  422.           Check := 0;
  423.           IF InhIndexCount^ [i] > 1 THEN
  424.          WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  425.          ForallClasses (Classes, EvalImplC);
  426.          WriteS (f, " }"); WriteNl (f);
  427.           ELSE
  428.          ForallClasses (Classes, EvalImplC);
  429.           END;
  430.           IF Check # InhIndexCount^ [i] THEN
  431.              MessageI ("internal error in yyI", Error, NoPosition, Short, ADR (i));
  432.           END;
  433.           WriteS (f, "}"); WriteNl (f);
  434.           WriteNl (f);
  435.        END;
  436.     END;
  437.     WriteS (f, "void Begin"); WI (EvalName); WriteS (f, " ()"); WriteNl (f);
  438.     WriteS (f, "{"); WriteNl (f);
  439.     WriteLine (EvalCodes^.Codes.BeginLine);
  440.     WriteText (f, EvalCodes^.Codes.Begin);
  441.     Node := Modules;
  442.     WHILE Node^.Kind = Tree.Module DO
  443.        WriteLine (Node^.Module.EvalCodes^.Codes.BeginLine);
  444.        WriteText (f, Node^.Module.EvalCodes^.Codes.Begin);
  445.        Node := Node^.Module.Next;
  446.     END;
  447.     WriteS (f, "}"); WriteNl (f);
  448.     WriteNl (f);
  449.     WriteS (f, "void Close"); WI (EvalName); WriteS (f, " ()"); WriteNl (f);
  450.     WriteS (f, "{"); WriteNl (f);
  451.     WriteLine (EvalCodes^.Codes.CloseLine);
  452.     WriteText (f, EvalCodes^.Codes.Close);
  453.     Node := Modules;
  454.     WHILE Node^.Kind = Tree.Module DO
  455.        WriteLine (Node^.Module.EvalCodes^.Codes.CloseLine);
  456.        WriteText (f, Node^.Module.EvalCodes^.Codes.Close);
  457.        Node := Node^.Module.Next;
  458.     END;
  459.     WriteS (f, "}"); WriteNl (f);
  460. ;
  461.       RETURN;
  462.      END;
  463.  
  464.   END;
  465.   IF (t^.Kind = Tree.Class) THEN
  466. (* line 319 "" *)
  467.     WITH yyTempo.yyR2 DO
  468.    LOOP
  469.      WITH t^.Class DO
  470. (* line 320 "" *)
  471.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  472. (* line 321 "" *)
  473.       IF NOT (i <= InstCount) THEN EXIT; END;
  474. (* line 322 "" *)
  475.       ;
  476. (* line 323 "" *)
  477.           a := ToAttr (t, i);
  478.     IF a = 0 THEN RETURN; END;
  479.     WITH Instance^ [a] DO
  480.        IF {Inherited, Right} <= Properties THEN
  481.           Class := t;
  482.           IF InhIndexCount^ [i] > 1 THEN
  483.          WriteS (f, "  case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  484.           END;
  485.           INC (Check);
  486.           k := ToBit1 (Selector, a - AttrCount - Selector^.Child.InstOffset);
  487.       IF IsElement (ORD ('5'), Options) THEN
  488.           WriteS (f, " IFNOTIN ("); WN (k MOD BSS); WriteS (f, ", yyt->"); WI (Class^.Class.Name);
  489.           WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, "->yyHead.yyIsDone"); WN (k DIV BSS);
  490.           WriteS (f, ") INCL (yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name);
  491.           WriteS (f, "->yyHead.yyIsDone"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, "); } else yyAbort (yyt);"); WriteNl (f);
  492.       END;
  493.           FOR j := 1 TO InstCount DO
  494.          IF IsRelated (a, j, DP) THEN
  495.             GenCall (t, j);
  496.          END;
  497.           END;
  498.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  499.           WriteS (f, 'yyWriteEval (yyt, "'); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  500.           IF (Action # ADR (Action)) AND NOT (Virtual IN Properties) THEN
  501.          EvalC.GenEvaluator (Action); WriteNl (f);
  502.          IF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  503.             WriteS (f, "write"); WI (itTree);
  504.             WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  505.             WriteS (f, "->"); WI (Selector^.Child.Type); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ")"); WriteNl (f);
  506.          ELSE
  507.             WriteS (f, "write"); WI (Attribute^.Child.Type);
  508.             WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  509.             WriteS (f, "->"); WI (Selector^.Child.Type); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ") yyWriteNl ();"); WriteNl (f);
  510.          END;
  511.           ELSE
  512.          WriteS (f, "yyWriteNl ();"); WriteNl (f);
  513.           END;
  514.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  515.           WriteS (f, 'yyWriteEval (yyt, "'); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  516.           IF (Action # ADR (Action)) AND NOT (Virtual IN Properties) THEN
  517.          EvalC.GenEvaluator (Action);
  518.           END;
  519.       ELSE
  520.           IF (Action # ADR (Action)) AND NOT (Virtual IN Properties) THEN
  521.          EvalC.GenEvaluator (Action);
  522.           END;
  523.       END;
  524.           IF NOT (Input IN Properties) AND (Attribute^.Kind = Tree.Child) THEN
  525.          WriteS (f, "{ register "); WI (itTree); WriteS (f, " yyr = yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  526.          WriteS (f, "->"); WI (Selector^.Child.Type); WriteS (f, "."); WI (Attribute^.Child.Name);
  527.          WriteS (f, "; if (yyr->yyHead.yyParent == "); WI (iNoTree);
  528.          WriteS (f, ") { yyr->yyHead.yyOffset = "); WN (Selector^.Child.Class^.Class.BitCount + Attribute^.Child.BitOffset);
  529.          WriteS (f, "; yyr->yyHead.yyParent = yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  530.          WriteS (f, "; Init"); WI (iModule); WriteS (f, " (yyr); } }"); WriteNl (f);
  531.           END;
  532.           FOR i2 := 1 TO InstCount DO    (* add group members *)
  533.          IF Instance^[i2].Action = Action THEN
  534.             WITH Instance^[i2] DO
  535.                IF Synthesized IN Properties THEN
  536.               k := ToBit0 (Class, i2);
  537.               WriteS (f, "  INCL (yyt->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ");"); WriteNl (f);
  538.                ELSIF Inherited IN Properties THEN
  539.               k := ToBit1 (Selector, i2 - AttrCount - Selector^.Child.InstOffset);
  540.               WriteS (f, "  INCL (yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name);
  541.               WriteS (f, "->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ");"); WriteNl (f);
  542.                END;
  543.             END;
  544.          END;
  545.           END;
  546.           WriteS (f, " return;"); WriteNl (f);
  547.        END;
  548.     END;
  549. ;
  550.       RETURN;
  551.      END;
  552.    END;
  553.     END;
  554.  
  555.   END;
  556.  END EvalImplC;
  557.  
  558. PROCEDURE CompBitInfo (t: Tree.tTree);
  559.  VAR yyTempo: RECORD CASE : INTEGER OF
  560.  END; END;
  561.  BEGIN
  562.   IF t = Tree.NoTree THEN RETURN; END;
  563.   IF (t^.Kind = Tree.Class) THEN
  564. (* line 399 "" *)
  565.      WITH t^.Class DO
  566. (* line 400 "" *)
  567.       BitIndexSize := AttrCount;
  568. (* line 401 "" *)
  569.       MakeArray (BitIndex, BitIndexSize, TSIZE (tBitInfo));
  570. (* line 402 "" *)
  571.       i := 1;
  572. (* line 403 "" *)
  573.       gBitIndex := BitIndex;
  574. (* line 404 "" *)
  575.       ForallAttributes (t, CompBitInfo);
  576. (* line 405 "" *)
  577.       MaxBit := Max (i, MaxBit);
  578. (* line 406 "" *)
  579.       MaxInstCount := Max (InstCount, MaxInstCount);
  580.       RETURN;
  581.      END;
  582.  
  583.   END;
  584.   IF (t^.Kind = Tree.Child) THEN
  585. (* line 408 "" *)
  586.    LOOP
  587.      WITH t^.Child DO
  588. (* line 410 "" *)
  589.       IF NOT (({Input, Test, Dummy} * Properties = {})) THEN EXIT; END;
  590. (* line 411 "" *)
  591.       INC (i);
  592. (* line 412 "" *)
  593.       gBitIndex ^ [AttrIndex] . ToBit := i;
  594. (* line 413 "" *)
  595.       gBitIndex ^ [i] . ToAttr := AttrIndex;
  596.       RETURN;
  597.      END;
  598.    END;
  599.  
  600.   END;
  601.   IF (t^.Kind = Tree.Attribute) THEN
  602. (* line 408 "" *)
  603.    LOOP
  604.      WITH t^.Attribute DO
  605. (* line 410 "" *)
  606.       IF NOT (({Input, Test, Dummy} * Properties = {})) THEN EXIT; END;
  607. (* line 411 "" *)
  608.       INC (i);
  609. (* line 412 "" *)
  610.       gBitIndex ^ [AttrIndex] . ToBit := i;
  611. (* line 413 "" *)
  612.       gBitIndex ^ [i] . ToAttr := AttrIndex;
  613.       RETURN;
  614.      END;
  615.    END;
  616.  
  617.   END;
  618.  END CompBitInfo;
  619.  
  620. PROCEDURE CompInhIndices (t: Tree.tTree);
  621.  VAR yyTempo: RECORD CASE : INTEGER OF
  622.  | 1: yyR1: RECORD
  623.   b: INTEGER;
  624.   END;
  625.  END; END;
  626.  BEGIN
  627.   IF t = Tree.NoTree THEN RETURN; END;
  628.   IF (t^.Kind = Tree.Class) THEN
  629. (* line 418 "" *)
  630.     WITH yyTempo.yyR1 DO
  631.      WITH t^.Class DO
  632. (* line 419 "" *)
  633.       ;
  634. (* line 420 "" *)
  635.           FOR j := AttrCount + 1 TO InstCount DO
  636.        WITH Instance^ [j] DO
  637.           IF Inherited IN Properties THEN
  638.          b := ToBit2 (t, Selector, j);
  639.          Include (InhIndices, b);
  640.          INC (InhIndexCount^ [b]);
  641.           END;
  642.        END;
  643.     END;
  644. ;
  645.       RETURN;
  646.      END;
  647.     END;
  648.  
  649.   END;
  650.  END CompInhIndices;
  651.  
  652. PROCEDURE CountSynAttr (t: Tree.tTree);
  653.  VAR yyTempo: RECORD CASE : INTEGER OF
  654.  END; END;
  655.  BEGIN
  656.   IF t = Tree.NoTree THEN RETURN; END;
  657.   IF (t^.Kind = Tree.Class) THEN
  658. (* line 433 "" *)
  659.    LOOP
  660.      WITH t^.Class DO
  661. (* line 434 "" *)
  662.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  663. (* line 435 "" *)
  664.       IF NOT (i <= BitCount) THEN EXIT; END;
  665. (* line 436 "" *)
  666.           WITH Instance^ [BitIndex^ [i].ToAttr] DO
  667.        IF ({Synthesized, Left} <= Properties) AND NOT (Test IN Properties) THEN
  668.           INC (n);
  669.        END;
  670.     END;
  671. ;
  672.       RETURN;
  673.      END;
  674.    END;
  675.  
  676.   END;
  677.  END CountSynAttr;
  678.  
  679. PROCEDURE TypeName (t: Tree.tTree);
  680.  VAR yyTempo: RECORD CASE : INTEGER OF
  681.  END; END;
  682.  BEGIN
  683.   IF t = Tree.NoTree THEN RETURN; END;
  684.   IF (t^.Kind = Tree.Class) THEN
  685. (* line 445 "" *)
  686.    LOOP
  687.      WITH t^.Class DO
  688. (* line 446 "" *)
  689.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  690. (* line 447 "" *)
  691.       IF NOT (Trace IN Properties) THEN EXIT; END;
  692. (* line 448 "" *)
  693.       WriteS (f, '"');
  694. (* line 448 "" *)
  695.       WI (Name);
  696. (* line 448 "" *)
  697.       WriteS (f, '",');
  698. (* line 448 "" *)
  699.       WriteNl (f);
  700.       RETURN;
  701.      END;
  702.    END;
  703.  
  704.   END;
  705.  END TypeName;
  706.  
  707. PROCEDURE GenS (t: Tree.tTree);
  708.  VAR yyTempo: RECORD CASE : INTEGER OF
  709.  END; END;
  710.  BEGIN
  711.   IF t = Tree.NoTree THEN RETURN; END;
  712.   IF (t^.Kind = Tree.Class) THEN
  713. (* line 453 "" *)
  714.    LOOP
  715.      WITH t^.Class DO
  716. (* line 454 "" *)
  717.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  718. (* line 455 "" *)
  719.       IF NOT (i <= BitCount) THEN EXIT; END;
  720. (* line 456 "" *)
  721.           WITH Instance^ [BitIndex^ [i].ToAttr] DO
  722.        IF ({Synthesized, Left} <= Properties) AND NOT (Test IN Properties) THEN
  723.           Class := t;
  724.           IF n > 1 THEN
  725.          WriteS (f, " case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  726.           END;
  727.           FOR j := 1 TO InstCount DO
  728.          IF IsRelated (BitIndex^ [i].ToAttr, j, DP) THEN
  729.             GenCall (t, j);
  730.          END;
  731.           END;
  732.           GenEvalAttr (t, BitIndex^ [i].ToAttr);
  733.           IF NOT (Input IN Properties) AND (Attribute^.Kind = Tree.Child) THEN
  734.          WriteS (f, "{ register "); WI (itTree); WriteS (f, " yyr = yyt->"); WI (Name); WriteS (f, "."); WI (Attribute^.Child.Name);
  735.          WriteS (f, "; if (yyr->yyHead.yyParent == "); WI (iNoTree);
  736.          WriteS (f, ") { yyr->yyHead.yyOffset = "); WN (BitCount + Attribute^.Child.BitOffset);
  737.          WriteS (f, "; yyr->yyHead.yyParent = yyt; Init"); WI (iModule); WriteS (f, " (yyr); } }"); WriteNl (f);
  738.           END;
  739.           FOR i2 := 1 TO InstCount DO    (* add group members *)
  740.          IF Instance^[i2].Action = Action THEN
  741.             WITH Instance^[i2] DO
  742.                IF Synthesized IN Properties THEN
  743.               k := ToBit0 (Class, i2);
  744.               IF k # i - 1 THEN
  745.                  WriteS (f, "  INCL (yyt->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ");"); WriteNl (f);
  746.               END;
  747.                ELSIF Inherited IN Properties THEN
  748.               k := ToBit1 (Selector, i2 - AttrCount - Selector^.Child.InstOffset);
  749.               WriteS (f, "  INCL (yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name);
  750.               WriteS (f, "->yyHead.yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ");"); WriteNl (f);
  751.                END;
  752.             END;
  753.          END;
  754.           END;
  755.           IF n > 1 THEN
  756.          WriteS (f, "  break;"); WriteNl (f);
  757.           END;
  758.        END;
  759.     END;
  760. ;
  761.       RETURN;
  762.      END;
  763.    END;
  764.  
  765.   END;
  766.  END GenS;
  767.  
  768. PROCEDURE GenE (t: Tree.tTree);
  769.  VAR yyTempo: RECORD CASE : INTEGER OF
  770.  | 1: yyR1: RECORD
  771.   ToCompute: tSet;
  772.   END;
  773.  END; END;
  774.  BEGIN
  775.   IF t = Tree.NoTree THEN RETURN; END;
  776.   IF (t^.Kind = Tree.Class) THEN
  777. (* line 499 "" *)
  778.     WITH yyTempo.yyR1 DO
  779.      WITH t^.Class DO
  780. (* line 500 "" *)
  781.       ;
  782. (* line 501 "" *)
  783.           GetIterator (t);
  784.     n := 0;
  785.     j := 2;
  786.     LOOP
  787.        IF j > InstCount THEN EXIT; END;
  788.        WITH Instance^ [j] DO
  789.           IF {Dummy, Output, Test} * Properties # {} THEN
  790.              IF (Test IN Properties) OR
  791.             ({Synthesized, Left} <= Properties) OR
  792.             ({Inherited,  Right} <= Properties) OR
  793.             ({Inherited,   Left} <= Properties) AND
  794.             NOT (Input IN Properties) AND (Attribute^.Kind = Tree.Child) OR
  795.             ({Synthesized, Right, Dummy} <= Properties) AND (Selector # Iterator) AND
  796.             (HasOutput IN Selector^.Child.Class^.Class.Properties) THEN
  797.             INC (n); EXIT;
  798.          END;
  799.           END;
  800.        END;
  801.        INC (j);
  802.     END;
  803.     IF (n = 0) AND ((Iterator = NoTree) OR NOT (HasOutput IN Iterator^.Child.Class^.Class.Properties)) THEN RETURN; END;
  804.  
  805.     Class := t;
  806.     WriteS (f, "  case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  807.     FOR j := 2 TO InstCount DO
  808.        WITH Instance^ [j] DO
  809.           IF {Dummy, Output} * Properties # {} THEN
  810.          IF ({Synthesized, Left} <= Properties) OR
  811.             ({Inherited,  Right} <= Properties) OR
  812.             ({Inherited,   Left} <= Properties) AND
  813.             NOT (Input IN Properties) AND (Attribute^.Kind = Tree.Child) THEN
  814.             GenCall (t, j);
  815.          ELSIF ({Synthesized, Right, Dummy} <= Properties) AND (Selector # Iterator) AND
  816.             (HasOutput IN Selector^.Child.Class^.Class.Properties) THEN
  817.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  818.             WriteS (f, 'yyWriteVisit (yyt, "'); WI (Selector^.Child.Name); WriteS (f, '"); '); 
  819.       END;
  820.             WriteS (f, "yyE (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, ");"); WriteNl (f);
  821.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  822.             WriteS (f, "yyVisitParent (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, ");"); WriteNl (f);
  823.       END;
  824.          END;
  825.           END;
  826.        END;
  827.     END;
  828.  
  829.     MakeSet (ToCompute, InstCount);
  830.     FOR i := 2 TO AttrCount DO
  831.        WITH Instance^ [i] DO
  832.           IF Test IN Properties THEN
  833.          FOR j := 2 TO InstCount DO
  834.             IF IsRelated (i, j, DP) THEN
  835.                IF {Synthesized, Inherited} * Instance^ [j].Properties # {} THEN
  836.               Include (ToCompute, j);
  837.                END;
  838.             END;
  839.          END;
  840.           END;
  841.        END;
  842.     END;
  843.     FOR i := 2 TO InstCount DO
  844.        WITH Instance^ [i] DO
  845.           IF ({Synthesized, Left, Output} <= Properties) OR
  846.          ({Inherited,  Right, Output} <= Properties) THEN
  847.          Exclude (ToCompute, i);
  848.           END;
  849.        END;
  850.     END;
  851.     WHILE NOT IsEmpty (ToCompute) DO
  852.        GenCall (t, Extract (ToCompute));
  853.     END;
  854.     ReleaseSet (ToCompute);
  855.     FOR i := 2 TO AttrCount DO
  856.        IF Test IN Instance^ [i].Properties THEN
  857.           GenEvalAttr (t, i);
  858.        END;
  859.     END;
  860.  
  861.     IF (Iterator = NoTree) OR NOT (HasOutput IN Iterator^.Child.Class^.Class.Properties) THEN
  862.        WriteS (f, "return;"); WriteNl (f);
  863.     ELSE
  864.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  865.        WriteS (f, 'yyWriteVisit (yyt, "'); WI (Iterator^.Child.Name); WriteS (f, '"); '); 
  866.       END;
  867.        WriteS (f, "yyt = yyt->"); WI (Name); WriteS (f, "."); WI (Iterator^.Child.Name); WriteS (f, "; break;"); WriteNl (f);
  868.     END;
  869. ;
  870.       RETURN;
  871.      END;
  872.     END;
  873.  
  874.   END;
  875.  END GenE;
  876.  
  877. PROCEDURE CompOutput (t: Tree.tTree);
  878.  VAR yyTempo: RECORD CASE : INTEGER OF
  879.  END; END;
  880.  BEGIN
  881.   IF t = Tree.NoTree THEN RETURN; END;
  882.   IF (t^.Kind = Tree.Class) THEN
  883. (* line 591 "" *)
  884.    LOOP
  885.      WITH t^.Class DO
  886. (* line 592 "" *)
  887.       IF NOT (NOT (HasOutput IN Properties)) THEN EXIT; END;
  888. (* line 593 "" *)
  889.       Success := FALSE;
  890. (* line 594 "" *)
  891.       ForallAttributes (t, CompOutput);
  892. (* line 595 "" *)
  893.       ForallClasses (Extensions, CompOutput2);
  894. (* line 596 "" *)
  895.       IF NOT (Success) THEN EXIT; END;
  896. (* line 597 "" *)
  897.       INCL (Properties, HasOutput);
  898. (* line 598 "" *)
  899.       IsStable := FALSE;
  900.       RETURN;
  901.      END;
  902.    END;
  903.  
  904.   END;
  905.   IF (t^.Kind = Tree.Child) THEN
  906. (* line 600 "" *)
  907.    LOOP
  908.      WITH t^.Child DO
  909. (* line 601 "" *)
  910.       IF NOT ((Output IN Properties) OR (HasOutput IN Class ^ . Class . Properties)) THEN EXIT; END;
  911. (* line 602 "" *)
  912.       Success := TRUE;
  913.       RETURN;
  914.      END;
  915.    END;
  916.  
  917.   END;
  918.   IF (t^.Kind = Tree.Attribute) THEN
  919. (* line 604 "" *)
  920.    LOOP
  921.      WITH t^.Attribute DO
  922. (* line 605 "" *)
  923.       IF NOT (({Test, Output} * Properties # {})) THEN EXIT; END;
  924. (* line 606 "" *)
  925.       Success := TRUE;
  926.       RETURN;
  927.      END;
  928.    END;
  929.  
  930.   END;
  931.  END CompOutput;
  932.  
  933. PROCEDURE CompOutput2 (t: Tree.tTree);
  934.  VAR yyTempo: RECORD CASE : INTEGER OF
  935.  END; END;
  936.  BEGIN
  937.   IF t = Tree.NoTree THEN RETURN; END;
  938.   IF (t^.Kind = Tree.Class) THEN
  939. (* line 611 "" *)
  940.    LOOP
  941.      WITH t^.Class DO
  942. (* line 612 "" *)
  943.       IF NOT (HasOutput IN Properties) THEN EXIT; END;
  944. (* line 613 "" *)
  945.       Success := TRUE;
  946.       RETURN;
  947.      END;
  948.    END;
  949.  
  950.   END;
  951.  END CompOutput2;
  952.  
  953. PROCEDURE ToBit0 (yyP2: Tree.tTree; yyP1: INTEGER): INTEGER;
  954.  VAR yyTempo: RECORD CASE : INTEGER OF
  955.  END; END;
  956.  BEGIN
  957. (* line 617 "" *)
  958.       RETURN yyP2 ^ . Class . BitIndex ^ [yyP1] . ToBit - 1;
  959.  
  960.  END ToBit0;
  961.  
  962. PROCEDURE ToBit1 (yyP4: Tree.tTree; yyP3: INTEGER): INTEGER;
  963.  VAR yyTempo: RECORD CASE : INTEGER OF
  964.  END; END;
  965.  BEGIN
  966. (* line 620 "" *)
  967.       RETURN yyP4 ^ . Child . Class ^ . Class . BitIndex ^ [yyP3] . ToBit - 1;
  968.  
  969.  END ToBit1;
  970.  
  971. PROCEDURE ToBit2 (yyP7: Tree.tTree; yyP6: Tree.tTree; yyP5: SHORTCARD): INTEGER;
  972.  VAR yyTempo: RECORD CASE : INTEGER OF
  973.  | 1: yyR1: RECORD
  974.   yyV1: INTEGER;
  975.   END;
  976.  END; END;
  977.  BEGIN
  978. (* line 623 "" *)
  979.     WITH yyTempo.yyR1 DO
  980. (* line 624 "" *)
  981.         WITH yyP6^.Child DO
  982.       RETURN yyP7^.Class.BitCount + BitOffset +
  983.      Class^.Class.BitIndex^ [yyP5 - yyP7^.Class.AttrCount - InstOffset].ToBit - 1;
  984.    END;
  985. ;
  986.       RETURN yyV1;
  987.     END;
  988.  
  989.  END ToBit2;
  990.  
  991. PROCEDURE ToAttr (yyP9: Tree.tTree; yyP8: INTEGER): INTEGER;
  992. (* line 631 "" *)
  993.  VAR a: SHORTCARD; 
  994.  VAR yyTempo: RECORD CASE : INTEGER OF
  995.  | 1: yyR1: RECORD
  996.   yyV1: INTEGER;
  997.   END;
  998.  END; END;
  999.  BEGIN
  1000. (* line 632 "" *)
  1001.     WITH yyTempo.yyR1 DO
  1002. (* line 633 "" *)
  1003.         WITH yyP9^.Class DO
  1004.       FOR a := AttrCount + 1 TO InstCount DO
  1005.      WITH Instance^ [a] DO
  1006.         IF ({Input, Test, Dummy} * Properties = {}) AND
  1007.            (ToBit2 (yyP9, Selector, a) = yyP8) THEN RETURN a; END;
  1008.      END;
  1009.       END;
  1010.    END;
  1011.    RETURN 0;
  1012. ;
  1013.       RETURN yyV1;
  1014.     END;
  1015.  
  1016.  END ToAttr;
  1017.  
  1018. PROCEDURE BeginEvalC3;
  1019.  BEGIN
  1020.  END BeginEvalC3;
  1021.  
  1022. PROCEDURE CloseEvalC3;
  1023.  BEGIN
  1024.  END CloseEvalC3;
  1025.  
  1026. PROCEDURE yyExit;
  1027.  BEGIN
  1028.   IO.CloseIO; System.Exit (1);
  1029.  END yyExit;
  1030.  
  1031. BEGIN
  1032.  yyf    := IO.StdOutput;
  1033.  Exit    := yyExit;
  1034.  BeginEvalC3;
  1035. END EvalC3.
  1036.